using System;
using System.Collections;
using System.ComponentModel;
using System.Data;
using System.Data.SqlClient;
using System.IO;
using System.Runtime.Serialization;
using System.Xml;
using System.Xml.Schema;
namespace SLS.Presentation.Data
{
	#region TABLELISTDataSet
	[Serializable()]
	[DesignerCategoryAttribute("code")]
	[System.Diagnostics.DebuggerStepThrough()]
	[ToolboxItem(true)]
	public class TABLELISTDataSet: DataSet
	{
		private TABLELISTDataTable _tableTABLELIST;
		
		[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content)]
		public TABLELISTDataTable TABLELIST
		{
			get
			{
				return this._tableTABLELIST;
			}
		}
		
		public TABLELISTDataSet()
		{
			this.InitClass();
		}
		
		protected override XmlSchema GetSchemaSerializable() 
		{
			MemoryStream stream = new MemoryStream();
			this.WriteXmlSchema(new	XmlTextWriter(stream, null));
			stream.Position = 0;
			return XmlSchema.Read(new XmlTextReader(stream), null);
		}
		
		protected override void	ReadXmlSerializable(XmlReader reader) 
		{
			this.Reset();
			DataSet ds = new DataSet();
			ds.ReadXml(reader);
			if ((ds.Tables["TABLELIST"] != null))
			{
				this.Tables.Add(new TABLELISTDataTable(ds.Tables["TABLELIST"]));
			}
			this.DataSetName = ds.DataSetName;
			this.Prefix = ds.Prefix;
			this.Namespace = ds.Namespace;
			this.Locale = ds.Locale;
			this.CaseSensitive = ds.CaseSensitive;
			this.EnforceConstraints = ds.EnforceConstraints;
			this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
			this.InitVars();
		}
		
		protected TABLELISTDataSet(SerializationInfo info, StreamingContext context)
		{
			string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
			if ((strSchema != null))
			{
				DataSet ds = new DataSet();
				ds.ReadXmlSchema(new XmlTextReader(new System.IO.StringReader(strSchema)));
				if ((ds.Tables["TABLELIST"] != null))
				{
					this.Tables.Add(new TABLELISTDataTable(ds.Tables["TABLELIST"]));
				}
				this.DataSetName = ds.DataSetName;
				this.Prefix = ds.Prefix;
				this.Namespace = ds.Namespace;
				this.Locale = ds.Locale;
				this.CaseSensitive = ds.CaseSensitive;
				this.EnforceConstraints = ds.EnforceConstraints;
				this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
				this.InitVars();
			}
			else
			{
				this.InitClass();
			}
			this.GetSerializationData(info, context);
		}
		
		private void InitClass()
		{
			this.DataSetName = "TABLELISTDataSet";
			_tableTABLELIST = new TABLELISTDataTable();
			this.Tables.Add(_tableTABLELIST);
			this.ExtendedProperties.Add("ObjectName", "TABLELIST");
			this.ExtendedProperties.Add("ObjectDescription", "TABLELIST");
			this.ExtendedProperties.Add("NameSpace", "");
		}
		
		public override DataSet Clone()
		{
			TABLELISTDataSet cln = ((TABLELISTDataSet)(base.Clone()));
			cln.InitVars();
			return cln;
		}
		
		internal void InitVars()
		{
			_tableTABLELIST = ((TABLELISTDataTable)(this.Tables["TABLELIST"]));
			if (_tableTABLELIST != null)
			{
				_tableTABLELIST.InitVars();
			}
		}
		
		protected override bool ShouldSerializeTables()
		{
			return false;
		}
		
		protected override bool ShouldSerializeRelations()
		{
			return false;
		}
		
		private bool ShouldSerializeTABLELIST()
		{
			return false;
		}
		
		public delegate void TABLELISTRowChangeEventHandler(object sender, TABLELISTRowChangeEventArgs e);
		
		[Serializable()]
		public class TABLELISTDataTable: DataTable, System.Collections.IEnumerable
		{
			private DataColumn _columnSM;
			private DataColumn _columnGTPRE;
			private DataColumn _columnGTKEY;
			private DataColumn _columnGDKEY;
			private DataColumn _columnTABLEID;
			private DataColumn _columnDBNAME;
			private DataColumn _columnTBNAME;
			private DataColumn _columnSNAME;
			private DataColumn _columnKCOND;
			private DataColumn _columnTBGROUP;
			private DataColumn _columnTBCLASS;
			private DataColumn _columnFKPROT;
			private DataColumn _columnSUBSTATUS;
			private DataColumn _columnSTATUS;
			private DataColumn _columnFUSER;
			private DataColumn _columnFDATE;
			private DataColumn _columnLUSER;
			private DataColumn _columnLDATE;
			private DataColumn _columnUID;
			
			internal TABLELISTDataTable(): base("TABLELIST")
			{
				this.InitClass();
			}
			
			protected TABLELISTDataTable(SerializationInfo info, StreamingContext context): base(info, context)
			{
				this.InitVars();
			}
			
			internal TABLELISTDataTable(DataTable table): base(table.TableName)
			{
				if (table.CaseSensitive != table.DataSet.CaseSensitive)
				{
					this.CaseSensitive = table.CaseSensitive;
				}
				if (table.Locale.ToString() != table.DataSet.Locale.ToString())
				{
					this.Locale = table.Locale;
				}
				if (table.Namespace != table.DataSet.Namespace)
				{
					this.Namespace = table.Namespace;
				}
				this.Prefix = table.Prefix;
				this.MinimumCapacity = table.MinimumCapacity;
				this.DisplayExpression = table.DisplayExpression;
			}
			
			public int Count
			{
				get
				{
					return this.Rows.Count;
				}
			}
			
			public DataColumn SMColumn
			{
				get
				{
					return _columnSM;
				}
			}
			
			public DataColumn GTPREColumn
			{
				get
				{
					return _columnGTPRE;
				}
			}
			
			public DataColumn GTKEYColumn
			{
				get
				{
					return _columnGTKEY;
				}
			}
			
			public DataColumn GDKEYColumn
			{
				get
				{
					return _columnGDKEY;
				}
			}
			
			public DataColumn TABLEIDColumn
			{
				get
				{
					return _columnTABLEID;
				}
			}
			
			public DataColumn DBNAMEColumn
			{
				get
				{
					return _columnDBNAME;
				}
			}
			
			public DataColumn TBNAMEColumn
			{
				get
				{
					return _columnTBNAME;
				}
			}
			
			public DataColumn SNAMEColumn
			{
				get
				{
					return _columnSNAME;
				}
			}
			
			public DataColumn KCONDColumn
			{
				get
				{
					return _columnKCOND;
				}
			}
			
			public DataColumn TBGROUPColumn
			{
				get
				{
					return _columnTBGROUP;
				}
			}
			
			public DataColumn TBCLASSColumn
			{
				get
				{
					return _columnTBCLASS;
				}
			}
			
			public DataColumn FKPROTColumn
			{
				get
				{
					return _columnFKPROT;
				}
			}
			
			public DataColumn SUBSTATUSColumn
			{
				get
				{
					return _columnSUBSTATUS;
				}
			}
			
			public DataColumn STATUSColumn
			{
				get
				{
					return _columnSTATUS;
				}
			}
			
			public DataColumn FUSERColumn
			{
				get
				{
					return _columnFUSER;
				}
			}
			
			public DataColumn FDATEColumn
			{
				get
				{
					return _columnFDATE;
				}
			}
			
			public DataColumn LUSERColumn
			{
				get
				{
					return _columnLUSER;
				}
			}
			
			public DataColumn LDATEColumn
			{
				get
				{
					return _columnLDATE;
				}
			}
			
			public DataColumn UIDColumn
			{
				get
				{
					return _columnUID;
				}
			}
			
			public TABLELISTRow this[int index]
			{
				get
				{
					return ((TABLELISTRow)(this.Rows[index]));
				}
			}
			
			public event TABLELISTRowChangeEventHandler TABLELISTRowChanged;
			public event TABLELISTRowChangeEventHandler TABLELISTRowChanging;
			public event TABLELISTRowChangeEventHandler TABLELISTRowDeleted;
			public event TABLELISTRowChangeEventHandler TABLELISTRowDeleting;
			
			public void AddTABLELISTRow(TABLELISTRow row)
			{
				this.Rows.Add(row);
			}
			
			public TABLELISTRow AddTABLELISTRow(
					string sm,
					string gtpre,
					string gtkey,
					string gdkey,
					string tableid,
					string dbname,
					string tbname,
					string sname,
					string kcond,
					string tbgroup,
					string tbclass,
					string fkprot,
					string substatus,
					string status,
					string fuser,
					DateTime fdate,
					string luser,
					DateTime ldate,
					string uid
				)
			{
				TABLELISTRow rowTABLELISTRow = ((TABLELISTRow)(this.NewRow()));
				rowTABLELISTRow["SM"] = sm;
				rowTABLELISTRow["GTPRE"] = gtpre;
				rowTABLELISTRow["GTKEY"] = gtkey;
				rowTABLELISTRow["GDKEY"] = gdkey;
				rowTABLELISTRow["TABLEID"] = tableid;
				rowTABLELISTRow["DBNAME"] = dbname;
				rowTABLELISTRow["TBNAME"] = tbname;
				rowTABLELISTRow["SNAME"] = sname;
				rowTABLELISTRow["KCOND"] = kcond;
				rowTABLELISTRow["TBGROUP"] = tbgroup;
				rowTABLELISTRow["TBCLASS"] = tbclass;
				rowTABLELISTRow["FKPROT"] = fkprot;
				rowTABLELISTRow["SUBSTATUS"] = substatus;
				rowTABLELISTRow["STATUS"] = status;
				rowTABLELISTRow["FUSER"] = fuser;
				rowTABLELISTRow["FDATE"] = fdate;
				rowTABLELISTRow["LUSER"] = luser;
				rowTABLELISTRow["LDATE"] = ldate;
				rowTABLELISTRow["UID"] = uid;
				this.Rows.Add(rowTABLELISTRow);
				return rowTABLELISTRow;
			}
			
			public IEnumerator GetEnumerator()
			{
				return this.Rows.GetEnumerator();
			}
			
			public override DataTable Clone()
			{
				TABLELISTDataTable cln = ((TABLELISTDataTable)(base.Clone()));
				cln.InitVars();
				return cln;
			}
			
			internal void InitVars()
			{
				_columnSM = this.Columns["SM"];
				_columnGTPRE = this.Columns["GTPRE"];
				_columnGTKEY = this.Columns["GTKEY"];
				_columnGDKEY = this.Columns["GDKEY"];
				_columnTABLEID = this.Columns["TABLEID"];
				_columnDBNAME = this.Columns["DBNAME"];
				_columnTBNAME = this.Columns["TBNAME"];
				_columnSNAME = this.Columns["SNAME"];
				_columnKCOND = this.Columns["KCOND"];
				_columnTBGROUP = this.Columns["TBGROUP"];
				_columnTBCLASS = this.Columns["TBCLASS"];
				_columnFKPROT = this.Columns["FKPROT"];
				_columnSUBSTATUS = this.Columns["SUBSTATUS"];
				_columnSTATUS = this.Columns["STATUS"];
				_columnFUSER = this.Columns["FUSER"];
				_columnFDATE = this.Columns["FDATE"];
				_columnLUSER = this.Columns["LUSER"];
				_columnLDATE = this.Columns["LDATE"];
				_columnUID = this.Columns["UID"];
			}
			
			public void InitClass()
			{
				_columnSM = new DataColumn("SM", typeof(string), "", MappingType.Element);
				_columnSM.AllowDBNull = false;
				_columnSM.Caption = "Sm";
				_columnSM.MaxLength = 2;
				_columnSM.Unique = false;
				_columnSM.DefaultValue = Convert.DBNull;
				_columnSM.ExtendedProperties.Add("IsKey", "true");
				_columnSM.ExtendedProperties.Add("ReadOnly", "false");
				_columnSM.ExtendedProperties.Add("Description", "Sm");
				_columnSM.ExtendedProperties.Add("Length", "2");
				_columnSM.ExtendedProperties.Add("Decimals", "0");
				_columnSM.ExtendedProperties.Add("AllowDBNulls", "false");
				this.Columns.Add(_columnSM);
				
				_columnGTPRE = new DataColumn("GTPRE", typeof(string), "", MappingType.Element);
				_columnGTPRE.AllowDBNull = true;
				_columnGTPRE.Caption = "Gtpre";
				_columnGTPRE.MaxLength = 2;
				_columnGTPRE.Unique = false;
				_columnGTPRE.DefaultValue = Convert.DBNull;
				_columnGTPRE.ExtendedProperties.Add("IsKey", "false");
				_columnGTPRE.ExtendedProperties.Add("ReadOnly", "false");
				_columnGTPRE.ExtendedProperties.Add("Description", "Gtpre");
				_columnGTPRE.ExtendedProperties.Add("Length", "2");
				_columnGTPRE.ExtendedProperties.Add("Decimals", "0");
				_columnGTPRE.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnGTPRE);
				
				_columnGTKEY = new DataColumn("GTKEY", typeof(string), "", MappingType.Element);
				_columnGTKEY.AllowDBNull = true;
				_columnGTKEY.Caption = "Gtkey";
				_columnGTKEY.MaxLength = 40;
				_columnGTKEY.Unique = false;
				_columnGTKEY.DefaultValue = Convert.DBNull;
				_columnGTKEY.ExtendedProperties.Add("IsKey", "false");
				_columnGTKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnGTKEY.ExtendedProperties.Add("Description", "Gtkey");
				_columnGTKEY.ExtendedProperties.Add("Length", "40");
				_columnGTKEY.ExtendedProperties.Add("Decimals", "0");
				_columnGTKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnGTKEY);
				
				_columnGDKEY = new DataColumn("GDKEY", typeof(string), "", MappingType.Element);
				_columnGDKEY.AllowDBNull = true;
				_columnGDKEY.Caption = "Gdkey";
				_columnGDKEY.MaxLength = 50;
				_columnGDKEY.Unique = false;
				_columnGDKEY.DefaultValue = Convert.DBNull;
				_columnGDKEY.ExtendedProperties.Add("IsKey", "false");
				_columnGDKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnGDKEY.ExtendedProperties.Add("Description", "Gdkey");
				_columnGDKEY.ExtendedProperties.Add("Length", "50");
				_columnGDKEY.ExtendedProperties.Add("Decimals", "0");
				_columnGDKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnGDKEY);
				
				_columnTABLEID = new DataColumn("TABLEID", typeof(string), "", MappingType.Element);
				_columnTABLEID.AllowDBNull = true;
				_columnTABLEID.Caption = "Tableid";
				_columnTABLEID.MaxLength = 50;
				_columnTABLEID.Unique = false;
				_columnTABLEID.DefaultValue = Convert.DBNull;
				_columnTABLEID.ExtendedProperties.Add("IsKey", "false");
				_columnTABLEID.ExtendedProperties.Add("ReadOnly", "false");
				_columnTABLEID.ExtendedProperties.Add("Description", "Tableid");
				_columnTABLEID.ExtendedProperties.Add("Length", "50");
				_columnTABLEID.ExtendedProperties.Add("Decimals", "0");
				_columnTABLEID.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnTABLEID);
				
				_columnDBNAME = new DataColumn("DBNAME", typeof(string), "", MappingType.Element);
				_columnDBNAME.AllowDBNull = false;
				_columnDBNAME.Caption = "Dbname";
				_columnDBNAME.MaxLength = 20;
				_columnDBNAME.Unique = false;
				_columnDBNAME.DefaultValue = Convert.DBNull;
				_columnDBNAME.ExtendedProperties.Add("IsKey", "true");
				_columnDBNAME.ExtendedProperties.Add("ReadOnly", "false");
				_columnDBNAME.ExtendedProperties.Add("Description", "Dbname");
				_columnDBNAME.ExtendedProperties.Add("Length", "20");
				_columnDBNAME.ExtendedProperties.Add("Decimals", "0");
				_columnDBNAME.ExtendedProperties.Add("AllowDBNulls", "false");
				this.Columns.Add(_columnDBNAME);
				
				_columnTBNAME = new DataColumn("TBNAME", typeof(string), "", MappingType.Element);
				_columnTBNAME.AllowDBNull = false;
				_columnTBNAME.Caption = "Tbname";
				_columnTBNAME.MaxLength = 100;
				_columnTBNAME.Unique = false;
				_columnTBNAME.DefaultValue = Convert.DBNull;
				_columnTBNAME.ExtendedProperties.Add("IsKey", "true");
				_columnTBNAME.ExtendedProperties.Add("ReadOnly", "false");
				_columnTBNAME.ExtendedProperties.Add("Description", "Tbname");
				_columnTBNAME.ExtendedProperties.Add("Length", "100");
				_columnTBNAME.ExtendedProperties.Add("Decimals", "0");
				_columnTBNAME.ExtendedProperties.Add("AllowDBNulls", "false");
				this.Columns.Add(_columnTBNAME);
				
				_columnSNAME = new DataColumn("SNAME", typeof(string), "", MappingType.Element);
				_columnSNAME.AllowDBNull = true;
				_columnSNAME.Caption = "Sname";
				_columnSNAME.MaxLength = 50;
				_columnSNAME.Unique = false;
				_columnSNAME.DefaultValue = Convert.DBNull;
				_columnSNAME.ExtendedProperties.Add("IsKey", "false");
				_columnSNAME.ExtendedProperties.Add("ReadOnly", "false");
				_columnSNAME.ExtendedProperties.Add("Description", "Sname");
				_columnSNAME.ExtendedProperties.Add("Length", "50");
				_columnSNAME.ExtendedProperties.Add("Decimals", "0");
				_columnSNAME.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSNAME);
				
				_columnKCOND = new DataColumn("KCOND", typeof(string), "", MappingType.Element);
				_columnKCOND.AllowDBNull = true;
				_columnKCOND.Caption = "Kcond";
				_columnKCOND.MaxLength = 50;
				_columnKCOND.Unique = false;
				_columnKCOND.DefaultValue = Convert.DBNull;
				_columnKCOND.ExtendedProperties.Add("IsKey", "false");
				_columnKCOND.ExtendedProperties.Add("ReadOnly", "false");
				_columnKCOND.ExtendedProperties.Add("Description", "Kcond");
				_columnKCOND.ExtendedProperties.Add("Length", "50");
				_columnKCOND.ExtendedProperties.Add("Decimals", "0");
				_columnKCOND.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnKCOND);
				
				_columnTBGROUP = new DataColumn("TBGROUP", typeof(string), "", MappingType.Element);
				_columnTBGROUP.AllowDBNull = true;
				_columnTBGROUP.Caption = "Tbgroup";
				_columnTBGROUP.MaxLength = 50;
				_columnTBGROUP.Unique = false;
				_columnTBGROUP.DefaultValue = Convert.DBNull;
				_columnTBGROUP.ExtendedProperties.Add("IsKey", "false");
				_columnTBGROUP.ExtendedProperties.Add("ReadOnly", "false");
				_columnTBGROUP.ExtendedProperties.Add("Description", "Tbgroup");
				_columnTBGROUP.ExtendedProperties.Add("Length", "50");
				_columnTBGROUP.ExtendedProperties.Add("Decimals", "0");
				_columnTBGROUP.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnTBGROUP);
				
				_columnTBCLASS = new DataColumn("TBCLASS", typeof(string), "", MappingType.Element);
				_columnTBCLASS.AllowDBNull = true;
				_columnTBCLASS.Caption = "Tbclass";
				_columnTBCLASS.MaxLength = 50;
				_columnTBCLASS.Unique = false;
				_columnTBCLASS.DefaultValue = Convert.DBNull;
				_columnTBCLASS.ExtendedProperties.Add("IsKey", "false");
				_columnTBCLASS.ExtendedProperties.Add("ReadOnly", "false");
				_columnTBCLASS.ExtendedProperties.Add("Description", "Tbclass");
				_columnTBCLASS.ExtendedProperties.Add("Length", "50");
				_columnTBCLASS.ExtendedProperties.Add("Decimals", "0");
				_columnTBCLASS.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnTBCLASS);
				
				_columnFKPROT = new DataColumn("FKPROT", typeof(string), "", MappingType.Element);
				_columnFKPROT.AllowDBNull = true;
				_columnFKPROT.Caption = "Fkprot";
				_columnFKPROT.MaxLength = 3;
				_columnFKPROT.Unique = false;
				_columnFKPROT.DefaultValue = Convert.DBNull;
				_columnFKPROT.ExtendedProperties.Add("IsKey", "false");
				_columnFKPROT.ExtendedProperties.Add("ReadOnly", "false");
				_columnFKPROT.ExtendedProperties.Add("Description", "Fkprot");
				_columnFKPROT.ExtendedProperties.Add("Length", "3");
				_columnFKPROT.ExtendedProperties.Add("Decimals", "0");
				_columnFKPROT.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnFKPROT);
				
				_columnSUBSTATUS = new DataColumn("SUBSTATUS", typeof(string), "", MappingType.Element);
				_columnSUBSTATUS.AllowDBNull = true;
				_columnSUBSTATUS.Caption = "Substatus";
				_columnSUBSTATUS.MaxLength = -1;
				_columnSUBSTATUS.Unique = false;
				_columnSUBSTATUS.DefaultValue = Convert.DBNull;
				_columnSUBSTATUS.ExtendedProperties.Add("IsKey", "false");
				_columnSUBSTATUS.ExtendedProperties.Add("ReadOnly", "false");
				_columnSUBSTATUS.ExtendedProperties.Add("Description", "Substatus");
				_columnSUBSTATUS.ExtendedProperties.Add("Length", "-1");
				_columnSUBSTATUS.ExtendedProperties.Add("Decimals", "0");
				_columnSUBSTATUS.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSUBSTATUS);
				
				_columnSTATUS = new DataColumn("STATUS", typeof(string), "", MappingType.Element);
				_columnSTATUS.AllowDBNull = true;
				_columnSTATUS.Caption = "Status";
				_columnSTATUS.MaxLength = 50;
				_columnSTATUS.Unique = false;
				_columnSTATUS.DefaultValue = Convert.DBNull;
				_columnSTATUS.ExtendedProperties.Add("IsKey", "false");
				_columnSTATUS.ExtendedProperties.Add("ReadOnly", "false");
				_columnSTATUS.ExtendedProperties.Add("Description", "Status");
				_columnSTATUS.ExtendedProperties.Add("Length", "50");
				_columnSTATUS.ExtendedProperties.Add("Decimals", "0");
				_columnSTATUS.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSTATUS);
				
				_columnFUSER = new DataColumn("FUSER", typeof(string), "", MappingType.Element);
				_columnFUSER.AllowDBNull = true;
				_columnFUSER.Caption = "Fuser";
				_columnFUSER.MaxLength = 50;
				_columnFUSER.Unique = false;
				_columnFUSER.DefaultValue = Convert.DBNull;
				_columnFUSER.ExtendedProperties.Add("IsKey", "false");
				_columnFUSER.ExtendedProperties.Add("ReadOnly", "false");
				_columnFUSER.ExtendedProperties.Add("Description", "Fuser");
				_columnFUSER.ExtendedProperties.Add("Length", "50");
				_columnFUSER.ExtendedProperties.Add("Decimals", "0");
				_columnFUSER.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnFUSER);
				
				_columnFDATE = new DataColumn("FDATE", typeof(DateTime), "", MappingType.Element);
				_columnFDATE.AllowDBNull = true;
				_columnFDATE.Caption = "Fdate";
				_columnFDATE.Unique = false;
				_columnFDATE.DefaultValue = Convert.DBNull;
				_columnFDATE.ExtendedProperties.Add("IsKey", "false");
				_columnFDATE.ExtendedProperties.Add("ReadOnly", "false");
				_columnFDATE.ExtendedProperties.Add("Description", "Fdate");
				_columnFDATE.ExtendedProperties.Add("Decimals", "0");
				_columnFDATE.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnFDATE);
				
				_columnLUSER = new DataColumn("LUSER", typeof(string), "", MappingType.Element);
				_columnLUSER.AllowDBNull = true;
				_columnLUSER.Caption = "Luser";
				_columnLUSER.MaxLength = 50;
				_columnLUSER.Unique = false;
				_columnLUSER.DefaultValue = Convert.DBNull;
				_columnLUSER.ExtendedProperties.Add("IsKey", "false");
				_columnLUSER.ExtendedProperties.Add("ReadOnly", "false");
				_columnLUSER.ExtendedProperties.Add("Description", "Luser");
				_columnLUSER.ExtendedProperties.Add("Length", "50");
				_columnLUSER.ExtendedProperties.Add("Decimals", "0");
				_columnLUSER.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnLUSER);
				
				_columnLDATE = new DataColumn("LDATE", typeof(DateTime), "", MappingType.Element);
				_columnLDATE.AllowDBNull = true;
				_columnLDATE.Caption = "Ldate";
				_columnLDATE.Unique = false;
				_columnLDATE.DefaultValue = Convert.DBNull;
				_columnLDATE.ExtendedProperties.Add("IsKey", "false");
				_columnLDATE.ExtendedProperties.Add("ReadOnly", "false");
				_columnLDATE.ExtendedProperties.Add("Description", "Ldate");
				_columnLDATE.ExtendedProperties.Add("Decimals", "0");
				_columnLDATE.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnLDATE);
				
				_columnUID = new DataColumn("UID", typeof(string), "", MappingType.Element);
				_columnUID.AllowDBNull = true;
				_columnUID.Caption = "Uid";
				_columnUID.MaxLength = 36;
				_columnUID.Unique = false;
				_columnUID.DefaultValue = Convert.DBNull;
				_columnUID.ExtendedProperties.Add("IsKey", "false");
				_columnUID.ExtendedProperties.Add("ReadOnly", "false");
				_columnUID.ExtendedProperties.Add("Description", "Uid");
				_columnUID.ExtendedProperties.Add("Length", "36");
				_columnUID.ExtendedProperties.Add("Decimals", "0");
				_columnUID.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnUID);
				
			}
			
			public TABLELISTRow NewTABLELISTRow()
			{
				TABLELISTRow rowTABLELISTRow = ((TABLELISTRow)(this.NewRow()));
				return rowTABLELISTRow;
			}
			
			protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
			{
				return new TABLELISTRow(builder);
			}
			
			protected override Type GetRowType()
			{
				return typeof(TABLELISTRow);
			}
			
			protected override void OnRowChanged(DataRowChangeEventArgs e)
			{
				base.OnRowChanged(e);
				if (this.TABLELISTRowChanged != null)
				{
					this.TABLELISTRowChanged(this, new TABLELISTRowChangeEventArgs(((TABLELISTRow)(e.Row)), e.Action));
				}
			}
			
			protected override void OnRowChanging(DataRowChangeEventArgs e)
			{
				base.OnRowChanging(e);
				if (this.TABLELISTRowChanging != null)
				{
					this.TABLELISTRowChanging(this, new TABLELISTRowChangeEventArgs(((TABLELISTRow)(e.Row)), e.Action));
				}
			}
			
			protected override void OnRowDeleted(DataRowChangeEventArgs e)
			{
				base.OnRowDeleted(e);
				if (this.TABLELISTRowDeleted != null)
				{
					this.TABLELISTRowDeleted(this, new TABLELISTRowChangeEventArgs(((TABLELISTRow)(e.Row)), e.Action));
				}
			}
			
			protected override void OnRowDeleting(DataRowChangeEventArgs e)
			{
				base.OnRowDeleting(e);
				if (this.TABLELISTRowDeleting != null)
				{
					this.TABLELISTRowDeleting(this, new TABLELISTRowChangeEventArgs(((TABLELISTRow)(e.Row)), e.Action));
				}
			}
			
			public void RemoveTABLELISTRow(TABLELISTRow row)
			{
				this.Rows.Remove(row);
			}
		}
		
		public class TABLELISTRow: DataRow
		{
			private TABLELISTDataTable _tableTABLELIST;
			
			internal TABLELISTRow(DataRowBuilder rb): base(rb)
			{
				_tableTABLELIST = ((TABLELISTDataTable)(this.Table));
			}
			
			/// <summary>
			/// Gets or sets the value of SM property
			/// </summary>
			public string SM
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.SMColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SM because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.SMColumn] = value;
				}
			}
			
			public bool IsSMNull()
			{
				return this.IsNull(_tableTABLELIST.SMColumn);
			}
			
			public void SetSMNull()
			{
				this[_tableTABLELIST.SMColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GTPRE property
			/// </summary>
			public string GTPRE
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.GTPREColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GTPRE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.GTPREColumn] = value;
				}
			}
			
			public bool IsGTPRENull()
			{
				return this.IsNull(_tableTABLELIST.GTPREColumn);
			}
			
			public void SetGTPRENull()
			{
				this[_tableTABLELIST.GTPREColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GTKEY property
			/// </summary>
			public string GTKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.GTKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GTKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.GTKEYColumn] = value;
				}
			}
			
			public bool IsGTKEYNull()
			{
				return this.IsNull(_tableTABLELIST.GTKEYColumn);
			}
			
			public void SetGTKEYNull()
			{
				this[_tableTABLELIST.GTKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GDKEY property
			/// </summary>
			public string GDKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.GDKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GDKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.GDKEYColumn] = value;
				}
			}
			
			public bool IsGDKEYNull()
			{
				return this.IsNull(_tableTABLELIST.GDKEYColumn);
			}
			
			public void SetGDKEYNull()
			{
				this[_tableTABLELIST.GDKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of TABLEID property
			/// </summary>
			public string TABLEID
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.TABLEIDColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value TABLEID because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.TABLEIDColumn] = value;
				}
			}
			
			public bool IsTABLEIDNull()
			{
				return this.IsNull(_tableTABLELIST.TABLEIDColumn);
			}
			
			public void SetTABLEIDNull()
			{
				this[_tableTABLELIST.TABLEIDColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of DBNAME property
			/// </summary>
			public string DBNAME
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.DBNAMEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value DBNAME because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.DBNAMEColumn] = value;
				}
			}
			
			public bool IsDBNAMENull()
			{
				return this.IsNull(_tableTABLELIST.DBNAMEColumn);
			}
			
			public void SetDBNAMENull()
			{
				this[_tableTABLELIST.DBNAMEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of TBNAME property
			/// </summary>
			public string TBNAME
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.TBNAMEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value TBNAME because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.TBNAMEColumn] = value;
				}
			}
			
			public bool IsTBNAMENull()
			{
				return this.IsNull(_tableTABLELIST.TBNAMEColumn);
			}
			
			public void SetTBNAMENull()
			{
				this[_tableTABLELIST.TBNAMEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SNAME property
			/// </summary>
			public string SNAME
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.SNAMEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SNAME because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.SNAMEColumn] = value;
				}
			}
			
			public bool IsSNAMENull()
			{
				return this.IsNull(_tableTABLELIST.SNAMEColumn);
			}
			
			public void SetSNAMENull()
			{
				this[_tableTABLELIST.SNAMEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of KCOND property
			/// </summary>
			public string KCOND
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.KCONDColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value KCOND because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.KCONDColumn] = value;
				}
			}
			
			public bool IsKCONDNull()
			{
				return this.IsNull(_tableTABLELIST.KCONDColumn);
			}
			
			public void SetKCONDNull()
			{
				this[_tableTABLELIST.KCONDColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of TBGROUP property
			/// </summary>
			public string TBGROUP
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.TBGROUPColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value TBGROUP because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.TBGROUPColumn] = value;
				}
			}
			
			public bool IsTBGROUPNull()
			{
				return this.IsNull(_tableTABLELIST.TBGROUPColumn);
			}
			
			public void SetTBGROUPNull()
			{
				this[_tableTABLELIST.TBGROUPColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of TBCLASS property
			/// </summary>
			public string TBCLASS
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.TBCLASSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value TBCLASS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.TBCLASSColumn] = value;
				}
			}
			
			public bool IsTBCLASSNull()
			{
				return this.IsNull(_tableTABLELIST.TBCLASSColumn);
			}
			
			public void SetTBCLASSNull()
			{
				this[_tableTABLELIST.TBCLASSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of FKPROT property
			/// </summary>
			public string FKPROT
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.FKPROTColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value FKPROT because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.FKPROTColumn] = value;
				}
			}
			
			public bool IsFKPROTNull()
			{
				return this.IsNull(_tableTABLELIST.FKPROTColumn);
			}
			
			public void SetFKPROTNull()
			{
				this[_tableTABLELIST.FKPROTColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SUBSTATUS property
			/// </summary>
			public string SUBSTATUS
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.SUBSTATUSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SUBSTATUS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.SUBSTATUSColumn] = value;
				}
			}
			
			public bool IsSUBSTATUSNull()
			{
				return this.IsNull(_tableTABLELIST.SUBSTATUSColumn);
			}
			
			public void SetSUBSTATUSNull()
			{
				this[_tableTABLELIST.SUBSTATUSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of STATUS property
			/// </summary>
			public string STATUS
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.STATUSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value STATUS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.STATUSColumn] = value;
				}
			}
			
			public bool IsSTATUSNull()
			{
				return this.IsNull(_tableTABLELIST.STATUSColumn);
			}
			
			public void SetSTATUSNull()
			{
				this[_tableTABLELIST.STATUSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of FUSER property
			/// </summary>
			public string FUSER
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.FUSERColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value FUSER because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.FUSERColumn] = value;
				}
			}
			
			public bool IsFUSERNull()
			{
				return this.IsNull(_tableTABLELIST.FUSERColumn);
			}
			
			public void SetFUSERNull()
			{
				this[_tableTABLELIST.FUSERColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of FDATE property
			/// </summary>
			public DateTime FDATE
			{
				get
				{
					try
					{
						return ((DateTime)(this[_tableTABLELIST.FDATEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value FDATE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.FDATEColumn] = value;
				}
			}
			
			public bool IsFDATENull()
			{
				return this.IsNull(_tableTABLELIST.FDATEColumn);
			}
			
			public void SetFDATENull()
			{
				this[_tableTABLELIST.FDATEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of LUSER property
			/// </summary>
			public string LUSER
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.LUSERColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value LUSER because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.LUSERColumn] = value;
				}
			}
			
			public bool IsLUSERNull()
			{
				return this.IsNull(_tableTABLELIST.LUSERColumn);
			}
			
			public void SetLUSERNull()
			{
				this[_tableTABLELIST.LUSERColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of LDATE property
			/// </summary>
			public DateTime LDATE
			{
				get
				{
					try
					{
						return ((DateTime)(this[_tableTABLELIST.LDATEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value LDATE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.LDATEColumn] = value;
				}
			}
			
			public bool IsLDATENull()
			{
				return this.IsNull(_tableTABLELIST.LDATEColumn);
			}
			
			public void SetLDATENull()
			{
				this[_tableTABLELIST.LDATEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of UID property
			/// </summary>
			public string UID
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELIST.UIDColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value UID because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELIST.UIDColumn] = value;
				}
			}
			
			public bool IsUIDNull()
			{
				return this.IsNull(_tableTABLELIST.UIDColumn);
			}
			
			public void SetUIDNull()
			{
				this[_tableTABLELIST.UIDColumn] = Convert.DBNull;
			}
			
		}
		
		public class TABLELISTRowChangeEventArgs: EventArgs
		{
			private TABLELISTRow _eventRow;
			private System.Data.DataRowAction _eventAction;
			
			public TABLELISTRowChangeEventArgs(TABLELISTRow row, DataRowAction action)
			{
				_eventRow = row;
				_eventAction = action;
			}
			
			public TABLELISTRow Row
			{
				get
				{
					return _eventRow;
				}
			}
			
			public DataRowAction Action
			{
				get
				{
					return _eventAction;
				}
			}
		}
	}
	#endregion
    #region TABLELISTQueryCondDataSet
	[Serializable()]
	[DesignerCategoryAttribute("code")]
	[System.Diagnostics.DebuggerStepThrough()]
	[ToolboxItem(true)]
	public class TABLELISTQueryCondDataSet: DataSet
	{
		private TABLELISTQueryCondDataTable _tableTABLELISTQueryCond;
		
		[DesignerSerializationVisibilityAttribute(DesignerSerializationVisibility.Content)]
		public TABLELISTQueryCondDataTable TABLELISTQueryCond
		{
			get
			{
				return this._tableTABLELISTQueryCond;
			}
		}
		
		public TABLELISTQueryCondDataSet()
		{
			this.InitClass();
		}
		
		protected override XmlSchema GetSchemaSerializable() 
		{
			MemoryStream stream = new MemoryStream();
			this.WriteXmlSchema(new	XmlTextWriter(stream, null));
			stream.Position = 0;
			return XmlSchema.Read(new XmlTextReader(stream), null);
		}
		
		protected override void	ReadXmlSerializable(XmlReader reader) 
		{
			this.Reset();
			DataSet ds = new DataSet();
			ds.ReadXml(reader);
			if ((ds.Tables["TABLELISTQueryCond"] != null))
			{
				this.Tables.Add(new TABLELISTQueryCondDataTable(ds.Tables["TABLELISTQueryCond"]));
			}
			this.DataSetName = ds.DataSetName;
			this.Prefix = ds.Prefix;
			this.Namespace = ds.Namespace;
			this.Locale = ds.Locale;
			this.CaseSensitive = ds.CaseSensitive;
			this.EnforceConstraints = ds.EnforceConstraints;
			this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
			this.InitVars();
		}
		
		protected TABLELISTQueryCondDataSet(SerializationInfo info, StreamingContext context)
		{
			string strSchema = ((string)(info.GetValue("XmlSchema", typeof(string))));
			if ((strSchema != null))
			{
				DataSet ds = new DataSet();
				ds.ReadXmlSchema(new XmlTextReader(new System.IO.StringReader(strSchema)));
				if ((ds.Tables["TABLELISTQueryCond"] != null))
				{
					this.Tables.Add(new TABLELISTQueryCondDataTable(ds.Tables["TABLELISTQueryCond"]));
				}
				this.DataSetName = ds.DataSetName;
				this.Prefix = ds.Prefix;
				this.Namespace = ds.Namespace;
				this.Locale = ds.Locale;
				this.CaseSensitive = ds.CaseSensitive;
				this.EnforceConstraints = ds.EnforceConstraints;
				this.Merge(ds, false, System.Data.MissingSchemaAction.Add);
				this.InitVars();
			}
			else
			{
				this.InitClass();
			}
			this.GetSerializationData(info, context);
		}
		
		private void InitClass()
		{
			this.DataSetName = "TABLELISTQueryCondDataSet";
			_tableTABLELISTQueryCond = new TABLELISTQueryCondDataTable();
			this.Tables.Add(_tableTABLELISTQueryCond);
			this.ExtendedProperties.Add("ObjectName", "TABLELISTQueryCond");
			this.ExtendedProperties.Add("ObjectDescription", "TABLELISTQueryCond");
			this.ExtendedProperties.Add("NameSpace", "");
		}
		
		public override DataSet Clone()
		{
			TABLELISTQueryCondDataSet cln = ((TABLELISTQueryCondDataSet)(base.Clone()));
			cln.InitVars();
			return cln;
		}
		
		internal void InitVars()
		{
			_tableTABLELISTQueryCond = ((TABLELISTQueryCondDataTable)(this.Tables["TABLELISTQueryCond"]));
			if (_tableTABLELISTQueryCond != null)
			{
				_tableTABLELISTQueryCond.InitVars();
			}
		}
		
		protected override bool ShouldSerializeTables()
		{
			return false;
		}
		
		protected override bool ShouldSerializeRelations()
		{
			return false;
		}
		
		private bool ShouldSerializeTABLELISTQueryCond()
		{
			return false;
		}
		
		public delegate void TABLELISTQueryCondRowChangeEventHandler(object sender, TABLELISTQueryCondRowChangeEventArgs e);
		
		[Serializable()]
		public class TABLELISTQueryCondDataTable: DataTable, System.Collections.IEnumerable
		{
			private DataColumn _columnQUERYTYPE;
			private DataColumn _columnCONDTYPE;
			private DataColumn _columnREASON1;
			private DataColumn _columnFKREAL;
			private DataColumn _columnSM;
			private DataColumn _columnUID;
			private DataColumn _columnGTPRE;
			private DataColumn _columnGTKEY;
			private DataColumn _columnGDKEY;
			private DataColumn _columnTABLEID;
			private DataColumn _columnTABLENAME;
			private DataColumn _columnSHORTNAME;
			private DataColumn _columnKEYCONDITION;
			private DataColumn _columnTABLEGROUP;
			private DataColumn _columnTABLECLASS;
			private DataColumn _columnFOREIGNKEYPROTECTED;
			private DataColumn _columnSUBSTATUS;
			private DataColumn _columnSTATUS;
			private DataColumn _columnFUSER;
			private DataColumn _columnFDATE;
			private DataColumn _columnLUSER;
			private DataColumn _columnLDATE;
			
			internal TABLELISTQueryCondDataTable(): base("TABLELISTQueryCond")
			{
				this.InitClass();
			}
			
			protected TABLELISTQueryCondDataTable(SerializationInfo info, StreamingContext context): base(info, context)
			{
				this.InitVars();
			}
			
			internal TABLELISTQueryCondDataTable(DataTable table): base(table.TableName)
			{
				if (table.CaseSensitive != table.DataSet.CaseSensitive)
				{
					this.CaseSensitive = table.CaseSensitive;
				}
				if (table.Locale.ToString() != table.DataSet.Locale.ToString())
				{
					this.Locale = table.Locale;
				}
				if (table.Namespace != table.DataSet.Namespace)
				{
					this.Namespace = table.Namespace;
				}
				this.Prefix = table.Prefix;
				this.MinimumCapacity = table.MinimumCapacity;
				this.DisplayExpression = table.DisplayExpression;
			}
			
			public int Count
			{
				get
				{
					return this.Rows.Count;
				}
			}
			
			public DataColumn QUERYTYPEColumn
			{
				get
				{
					return _columnQUERYTYPE;
				}
			}
			
			public DataColumn CONDTYPEColumn
			{
				get
				{
					return _columnCONDTYPE;
				}
			}
			
			public DataColumn REASON1Column
			{
				get
				{
					return _columnREASON1;
				}
			}
			
			public DataColumn FKREALColumn
			{
				get
				{
					return _columnFKREAL;
				}
			}
			
			public DataColumn SMColumn
			{
				get
				{
					return _columnSM;
				}
			}
			
			public DataColumn UIDColumn
			{
				get
				{
					return _columnUID;
				}
			}
			
			public DataColumn GTPREColumn
			{
				get
				{
					return _columnGTPRE;
				}
			}
			
			public DataColumn GTKEYColumn
			{
				get
				{
					return _columnGTKEY;
				}
			}
			
			public DataColumn GDKEYColumn
			{
				get
				{
					return _columnGDKEY;
				}
			}
			
			public DataColumn TABLEIDColumn
			{
				get
				{
					return _columnTABLEID;
				}
			}
			
			public DataColumn TABLENAMEColumn
			{
				get
				{
					return _columnTABLENAME;
				}
			}
			
			public DataColumn SHORTNAMEColumn
			{
				get
				{
					return _columnSHORTNAME;
				}
			}
			
			public DataColumn KEYCONDITIONColumn
			{
				get
				{
					return _columnKEYCONDITION;
				}
			}
			
			public DataColumn TABLEGROUPColumn
			{
				get
				{
					return _columnTABLEGROUP;
				}
			}
			
			public DataColumn TABLECLASSColumn
			{
				get
				{
					return _columnTABLECLASS;
				}
			}
			
			public DataColumn FOREIGNKEYPROTECTEDColumn
			{
				get
				{
					return _columnFOREIGNKEYPROTECTED;
				}
			}
			
			public DataColumn SUBSTATUSColumn
			{
				get
				{
					return _columnSUBSTATUS;
				}
			}
			
			public DataColumn STATUSColumn
			{
				get
				{
					return _columnSTATUS;
				}
			}
			
			public DataColumn FUSERColumn
			{
				get
				{
					return _columnFUSER;
				}
			}
			
			public DataColumn FDATEColumn
			{
				get
				{
					return _columnFDATE;
				}
			}
			
			public DataColumn LUSERColumn
			{
				get
				{
					return _columnLUSER;
				}
			}
			
			public DataColumn LDATEColumn
			{
				get
				{
					return _columnLDATE;
				}
			}
			
			public TABLELISTQueryCondRow this[int index]
			{
				get
				{
					return ((TABLELISTQueryCondRow)(this.Rows[index]));
				}
			}
			
			public event TABLELISTQueryCondRowChangeEventHandler TABLELISTQueryCondRowChanged;
			public event TABLELISTQueryCondRowChangeEventHandler TABLELISTQueryCondRowChanging;
			public event TABLELISTQueryCondRowChangeEventHandler TABLELISTQueryCondRowDeleted;
			public event TABLELISTQueryCondRowChangeEventHandler TABLELISTQueryCondRowDeleting;
			
			public void AddTABLELISTQueryCondRow(TABLELISTQueryCondRow row)
			{
				this.Rows.Add(row);
			}
			
			public TABLELISTQueryCondRow AddTABLELISTQueryCondRow(
					string querytype,
					string condtype,
					string reason1,
					string fkreal,
					string sm,
					string uid,
					string gtpre,
					string gtkey,
					string gdkey,
					string tableid,
					string tablename,
					string shortname,
					string keycondition,
					string tablegroup,
					string tableclass,
					string foreignkeyprotected,
					string substatus,
					string status,
					string fuser,
					DateTime fdate,
					string luser,
					DateTime ldate
				)
			{
				TABLELISTQueryCondRow rowTABLELISTQueryCondRow = ((TABLELISTQueryCondRow)(this.NewRow()));
				rowTABLELISTQueryCondRow["QUERYTYPE"] = querytype;
				rowTABLELISTQueryCondRow["CONDTYPE"] = condtype;
				rowTABLELISTQueryCondRow["REASON1"] = reason1;
				rowTABLELISTQueryCondRow["FKREAL"] = fkreal;
				rowTABLELISTQueryCondRow["SM"] = sm;
				rowTABLELISTQueryCondRow["UID"] = uid;
				rowTABLELISTQueryCondRow["GTPRE"] = gtpre;
				rowTABLELISTQueryCondRow["GTKEY"] = gtkey;
				rowTABLELISTQueryCondRow["GDKEY"] = gdkey;
				rowTABLELISTQueryCondRow["TABLEID"] = tableid;
				rowTABLELISTQueryCondRow["TABLENAME"] = tablename;
				rowTABLELISTQueryCondRow["SHORTNAME"] = shortname;
				rowTABLELISTQueryCondRow["KEYCONDITION"] = keycondition;
				rowTABLELISTQueryCondRow["TABLEGROUP"] = tablegroup;
				rowTABLELISTQueryCondRow["TABLECLASS"] = tableclass;
				rowTABLELISTQueryCondRow["FOREIGNKEYPROTECTED"] = foreignkeyprotected;
				rowTABLELISTQueryCondRow["SUBSTATUS"] = substatus;
				rowTABLELISTQueryCondRow["STATUS"] = status;
				rowTABLELISTQueryCondRow["FUSER"] = fuser;
				rowTABLELISTQueryCondRow["FDATE"] = fdate;
				rowTABLELISTQueryCondRow["LUSER"] = luser;
				rowTABLELISTQueryCondRow["LDATE"] = ldate;
				this.Rows.Add(rowTABLELISTQueryCondRow);
				return rowTABLELISTQueryCondRow;
			} 
			 
			public IEnumerator GetEnumerator()
			{
				return this.Rows.GetEnumerator();
			}
			
			public override DataTable Clone()
			{
				TABLELISTQueryCondDataTable cln = ((TABLELISTQueryCondDataTable)(base.Clone()));
				cln.InitVars();
				return cln;
			}
			
			internal void InitVars()
			{
				_columnQUERYTYPE = this.Columns["QUERYTYPE"];
				_columnCONDTYPE = this.Columns["CONDTYPE"];
				_columnREASON1 = this.Columns["REASON1"];
				_columnFKREAL = this.Columns["FKREAL"];
				_columnSM = this.Columns["SM"];
				_columnUID = this.Columns["UID"];
				_columnGTPRE = this.Columns["GTPRE"];
				_columnGTKEY = this.Columns["GTKEY"];
				_columnGDKEY = this.Columns["GDKEY"];
				_columnTABLEID = this.Columns["TABLEID"];
				_columnTABLENAME = this.Columns["TABLENAME"];
				_columnSHORTNAME = this.Columns["SHORTNAME"];
				_columnKEYCONDITION = this.Columns["KEYCONDITION"];
				_columnTABLEGROUP = this.Columns["TABLEGROUP"];
				_columnTABLECLASS = this.Columns["TABLECLASS"];
				_columnFOREIGNKEYPROTECTED = this.Columns["FOREIGNKEYPROTECTED"];
				_columnSUBSTATUS = this.Columns["SUBSTATUS"];
				_columnSTATUS = this.Columns["STATUS"];
				_columnFUSER = this.Columns["FUSER"];
				_columnFDATE = this.Columns["FDATE"];
				_columnLUSER = this.Columns["LUSER"];
				_columnLDATE = this.Columns["LDATE"];
			}
			
			public void InitClass()
			{
				_columnQUERYTYPE = new DataColumn("QUERYTYPE", typeof(string), "", MappingType.Element);
				_columnQUERYTYPE.AllowDBNull = false;
				_columnQUERYTYPE.Caption = "Querytype";
				_columnQUERYTYPE.MaxLength = 50;
				_columnQUERYTYPE.Unique = false;
				_columnQUERYTYPE.DefaultValue = Convert.DBNull;
				_columnQUERYTYPE.ExtendedProperties.Add("IsKey", "false");
				_columnQUERYTYPE.ExtendedProperties.Add("ReadOnly", "false");
				_columnQUERYTYPE.ExtendedProperties.Add("Description", "Querytype");
				_columnQUERYTYPE.ExtendedProperties.Add("Length", "50");
				_columnQUERYTYPE.ExtendedProperties.Add("Decimals", "0");
				_columnQUERYTYPE.ExtendedProperties.Add("AllowDBNulls", "false");
				this.Columns.Add(_columnQUERYTYPE);
				
				_columnCONDTYPE = new DataColumn("CONDTYPE", typeof(string), "", MappingType.Element);
				_columnCONDTYPE.AllowDBNull = false;
				_columnCONDTYPE.Caption = "Condtype";
				_columnCONDTYPE.MaxLength = 250;
				_columnCONDTYPE.Unique = false;
				_columnCONDTYPE.DefaultValue = Convert.DBNull;
				_columnCONDTYPE.ExtendedProperties.Add("IsKey", "false");
				_columnCONDTYPE.ExtendedProperties.Add("ReadOnly", "false");
				_columnCONDTYPE.ExtendedProperties.Add("Description", "Condtype");
				_columnCONDTYPE.ExtendedProperties.Add("Length", "250");
				_columnCONDTYPE.ExtendedProperties.Add("Decimals", "0");
				_columnCONDTYPE.ExtendedProperties.Add("AllowDBNulls", "false");
				this.Columns.Add(_columnCONDTYPE);
				
				_columnREASON1 = new DataColumn("REASON1", typeof(string), "", MappingType.Element);
				_columnREASON1.AllowDBNull = true;
				_columnREASON1.Caption = "Reason 1";
				_columnREASON1.MaxLength = 100;
				_columnREASON1.Unique = false;
				_columnREASON1.DefaultValue = Convert.DBNull;
				_columnREASON1.ExtendedProperties.Add("IsKey", "false");
				_columnREASON1.ExtendedProperties.Add("ReadOnly", "false");
				_columnREASON1.ExtendedProperties.Add("Description", "Reason 1");
				_columnREASON1.ExtendedProperties.Add("Length", "100");
				_columnREASON1.ExtendedProperties.Add("Decimals", "0");
				_columnREASON1.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnREASON1);
				
				_columnFKREAL = new DataColumn("FKREAL", typeof(string), "", MappingType.Element);
				_columnFKREAL.AllowDBNull = true;
				_columnFKREAL.Caption = "Fkreal";
				_columnFKREAL.MaxLength = 100;
				_columnFKREAL.Unique = false;
				_columnFKREAL.DefaultValue = Convert.DBNull;
				_columnFKREAL.ExtendedProperties.Add("IsKey", "false");
				_columnFKREAL.ExtendedProperties.Add("ReadOnly", "false");
				_columnFKREAL.ExtendedProperties.Add("Description", "Fkreal");
				_columnFKREAL.ExtendedProperties.Add("Length", "100");
				_columnFKREAL.ExtendedProperties.Add("Decimals", "0");
				_columnFKREAL.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnFKREAL);
				
				_columnSM = new DataColumn("SM", typeof(string), "", MappingType.Element);
				_columnSM.AllowDBNull = true;
				_columnSM.Caption = "Sm";
				_columnSM.MaxLength = 10;
				_columnSM.Unique = false;
				_columnSM.DefaultValue = Convert.DBNull;
				_columnSM.ExtendedProperties.Add("IsKey", "false");
				_columnSM.ExtendedProperties.Add("ReadOnly", "false");
				_columnSM.ExtendedProperties.Add("Description", "Sm");
				_columnSM.ExtendedProperties.Add("Length", "10");
				_columnSM.ExtendedProperties.Add("Decimals", "0");
				_columnSM.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSM);
				
				_columnUID = new DataColumn("UID", typeof(string), "", MappingType.Element);
				_columnUID.AllowDBNull = true;
				_columnUID.Caption = "Uid";
				_columnUID.MaxLength = 256;
				_columnUID.Unique = false;
				_columnUID.DefaultValue = Convert.DBNull;
				_columnUID.ExtendedProperties.Add("IsKey", "false");
				_columnUID.ExtendedProperties.Add("ReadOnly", "false");
				_columnUID.ExtendedProperties.Add("Description", "Uid");
				_columnUID.ExtendedProperties.Add("Length", "256");
				_columnUID.ExtendedProperties.Add("Decimals", "0");
				_columnUID.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnUID);
				
				_columnGTPRE = new DataColumn("GTPRE", typeof(string), "", MappingType.Element);
				_columnGTPRE.AllowDBNull = true;
				_columnGTPRE.Caption = "Gtpre";
				_columnGTPRE.MaxLength = 2;
				_columnGTPRE.Unique = false;
				_columnGTPRE.DefaultValue = Convert.DBNull;
				_columnGTPRE.ExtendedProperties.Add("IsKey", "false");
				_columnGTPRE.ExtendedProperties.Add("ReadOnly", "false");
				_columnGTPRE.ExtendedProperties.Add("Description", "Gtpre");
				_columnGTPRE.ExtendedProperties.Add("Length", "2");
				_columnGTPRE.ExtendedProperties.Add("Decimals", "0");
				_columnGTPRE.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnGTPRE);
				
				_columnGTKEY = new DataColumn("GTKEY", typeof(string), "", MappingType.Element);
				_columnGTKEY.AllowDBNull = true;
				_columnGTKEY.Caption = "Gtkey";
				_columnGTKEY.MaxLength = 40;
				_columnGTKEY.Unique = false;
				_columnGTKEY.DefaultValue = Convert.DBNull;
				_columnGTKEY.ExtendedProperties.Add("IsKey", "false");
				_columnGTKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnGTKEY.ExtendedProperties.Add("Description", "Gtkey");
				_columnGTKEY.ExtendedProperties.Add("Length", "40");
				_columnGTKEY.ExtendedProperties.Add("Decimals", "0");
				_columnGTKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnGTKEY);
				
				_columnGDKEY = new DataColumn("GDKEY", typeof(string), "", MappingType.Element);
				_columnGDKEY.AllowDBNull = true;
				_columnGDKEY.Caption = "Gdkey";
				_columnGDKEY.MaxLength = 50;
				_columnGDKEY.Unique = false;
				_columnGDKEY.DefaultValue = Convert.DBNull;
				_columnGDKEY.ExtendedProperties.Add("IsKey", "false");
				_columnGDKEY.ExtendedProperties.Add("ReadOnly", "false");
				_columnGDKEY.ExtendedProperties.Add("Description", "Gdkey");
				_columnGDKEY.ExtendedProperties.Add("Length", "50");
				_columnGDKEY.ExtendedProperties.Add("Decimals", "0");
				_columnGDKEY.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnGDKEY);
				
				_columnTABLEID = new DataColumn("TABLEID", typeof(string), "", MappingType.Element);
				_columnTABLEID.AllowDBNull = true;
				_columnTABLEID.Caption = "Tableid";
				_columnTABLEID.Unique = false;
				_columnTABLEID.DefaultValue = Convert.DBNull;
				_columnTABLEID.ExtendedProperties.Add("IsKey", "false");
				_columnTABLEID.ExtendedProperties.Add("ReadOnly", "false");
				_columnTABLEID.ExtendedProperties.Add("Description", "Tableid");
				_columnTABLEID.ExtendedProperties.Add("Decimals", "0");
				_columnTABLEID.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnTABLEID);
				
				_columnTABLENAME = new DataColumn("TABLENAME", typeof(string), "", MappingType.Element);
				_columnTABLENAME.AllowDBNull = true;
				_columnTABLENAME.Caption = "Tablename";
				_columnTABLENAME.MaxLength = 100;
				_columnTABLENAME.Unique = false;
				_columnTABLENAME.DefaultValue = Convert.DBNull;
				_columnTABLENAME.ExtendedProperties.Add("IsKey", "false");
				_columnTABLENAME.ExtendedProperties.Add("ReadOnly", "false");
				_columnTABLENAME.ExtendedProperties.Add("Description", "Tablename");
				_columnTABLENAME.ExtendedProperties.Add("Length", "100");
				_columnTABLENAME.ExtendedProperties.Add("Decimals", "0");
				_columnTABLENAME.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnTABLENAME);
				
				_columnSHORTNAME = new DataColumn("SHORTNAME", typeof(string), "", MappingType.Element);
				_columnSHORTNAME.AllowDBNull = true;
				_columnSHORTNAME.Caption = "Shortname";
				_columnSHORTNAME.Unique = false;
				_columnSHORTNAME.DefaultValue = Convert.DBNull;
				_columnSHORTNAME.ExtendedProperties.Add("IsKey", "false");
				_columnSHORTNAME.ExtendedProperties.Add("ReadOnly", "false");
				_columnSHORTNAME.ExtendedProperties.Add("Description", "Shortname");
				_columnSHORTNAME.ExtendedProperties.Add("Decimals", "0");
				_columnSHORTNAME.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSHORTNAME);
				
				_columnKEYCONDITION = new DataColumn("KEYCONDITION", typeof(string), "", MappingType.Element);
				_columnKEYCONDITION.AllowDBNull = true;
				_columnKEYCONDITION.Caption = "Keycondition";
				_columnKEYCONDITION.MaxLength = 50;
				_columnKEYCONDITION.Unique = false;
				_columnKEYCONDITION.DefaultValue = Convert.DBNull;
				_columnKEYCONDITION.ExtendedProperties.Add("IsKey", "false");
				_columnKEYCONDITION.ExtendedProperties.Add("ReadOnly", "false");
				_columnKEYCONDITION.ExtendedProperties.Add("Description", "Keycondition");
				_columnKEYCONDITION.ExtendedProperties.Add("Length", "50");
				_columnKEYCONDITION.ExtendedProperties.Add("Decimals", "0");
				_columnKEYCONDITION.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnKEYCONDITION);
				
				_columnTABLEGROUP = new DataColumn("TABLEGROUP", typeof(string), "", MappingType.Element);
				_columnTABLEGROUP.AllowDBNull = true;
				_columnTABLEGROUP.Caption = "Tablegroup";
				_columnTABLEGROUP.MaxLength = 50;
				_columnTABLEGROUP.Unique = false;
				_columnTABLEGROUP.DefaultValue = Convert.DBNull;
				_columnTABLEGROUP.ExtendedProperties.Add("IsKey", "false");
				_columnTABLEGROUP.ExtendedProperties.Add("ReadOnly", "false");
				_columnTABLEGROUP.ExtendedProperties.Add("Description", "Tablegroup");
				_columnTABLEGROUP.ExtendedProperties.Add("Length", "50");
				_columnTABLEGROUP.ExtendedProperties.Add("Decimals", "0");
				_columnTABLEGROUP.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnTABLEGROUP);
				
				_columnTABLECLASS = new DataColumn("TABLECLASS", typeof(string), "", MappingType.Element);
				_columnTABLECLASS.AllowDBNull = true;
				_columnTABLECLASS.Caption = "Tableclass";
				_columnTABLECLASS.MaxLength = 50;
				_columnTABLECLASS.Unique = false;
				_columnTABLECLASS.DefaultValue = Convert.DBNull;
				_columnTABLECLASS.ExtendedProperties.Add("IsKey", "false");
				_columnTABLECLASS.ExtendedProperties.Add("ReadOnly", "false");
				_columnTABLECLASS.ExtendedProperties.Add("Description", "Tableclass");
				_columnTABLECLASS.ExtendedProperties.Add("Length", "50");
				_columnTABLECLASS.ExtendedProperties.Add("Decimals", "0");
				_columnTABLECLASS.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnTABLECLASS);
				
				_columnFOREIGNKEYPROTECTED = new DataColumn("FOREIGNKEYPROTECTED", typeof(string), "", MappingType.Element);
				_columnFOREIGNKEYPROTECTED.AllowDBNull = true;
				_columnFOREIGNKEYPROTECTED.Caption = "Foreignkeyprotected";
				_columnFOREIGNKEYPROTECTED.MaxLength = 3;
				_columnFOREIGNKEYPROTECTED.Unique = false;
				_columnFOREIGNKEYPROTECTED.DefaultValue = Convert.DBNull;
				_columnFOREIGNKEYPROTECTED.ExtendedProperties.Add("IsKey", "false");
				_columnFOREIGNKEYPROTECTED.ExtendedProperties.Add("ReadOnly", "false");
				_columnFOREIGNKEYPROTECTED.ExtendedProperties.Add("Description", "Foreignkeyprotected");
				_columnFOREIGNKEYPROTECTED.ExtendedProperties.Add("Length", "3");
				_columnFOREIGNKEYPROTECTED.ExtendedProperties.Add("Decimals", "0");
				_columnFOREIGNKEYPROTECTED.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnFOREIGNKEYPROTECTED);
				
				_columnSUBSTATUS = new DataColumn("SUBSTATUS", typeof(string), "", MappingType.Element);
				_columnSUBSTATUS.AllowDBNull = true;
				_columnSUBSTATUS.Caption = "Substatus";
				_columnSUBSTATUS.MaxLength = -1;
				_columnSUBSTATUS.Unique = false;
				_columnSUBSTATUS.DefaultValue = Convert.DBNull;
				_columnSUBSTATUS.ExtendedProperties.Add("IsKey", "false");
				_columnSUBSTATUS.ExtendedProperties.Add("ReadOnly", "false");
				_columnSUBSTATUS.ExtendedProperties.Add("Description", "Substatus");
				_columnSUBSTATUS.ExtendedProperties.Add("Length", "-1");
				_columnSUBSTATUS.ExtendedProperties.Add("Decimals", "0");
				_columnSUBSTATUS.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSUBSTATUS);
				
				_columnSTATUS = new DataColumn("STATUS", typeof(string), "", MappingType.Element);
				_columnSTATUS.AllowDBNull = true;
				_columnSTATUS.Caption = "Status";
				_columnSTATUS.MaxLength = 50;
				_columnSTATUS.Unique = false;
				_columnSTATUS.DefaultValue = Convert.DBNull;
				_columnSTATUS.ExtendedProperties.Add("IsKey", "false");
				_columnSTATUS.ExtendedProperties.Add("ReadOnly", "false");
				_columnSTATUS.ExtendedProperties.Add("Description", "Status");
				_columnSTATUS.ExtendedProperties.Add("Length", "50");
				_columnSTATUS.ExtendedProperties.Add("Decimals", "0");
				_columnSTATUS.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnSTATUS);
				
				_columnFUSER = new DataColumn("FUSER", typeof(string), "", MappingType.Element);
				_columnFUSER.AllowDBNull = true;
				_columnFUSER.Caption = "Fuser";
				_columnFUSER.Unique = false;
				_columnFUSER.DefaultValue = Convert.DBNull;
				_columnFUSER.ExtendedProperties.Add("IsKey", "false");
				_columnFUSER.ExtendedProperties.Add("ReadOnly", "false");
				_columnFUSER.ExtendedProperties.Add("Description", "Fuser");
				_columnFUSER.ExtendedProperties.Add("Decimals", "0");
				_columnFUSER.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnFUSER);
				
				_columnFDATE = new DataColumn("FDATE", typeof(DateTime), "", MappingType.Element);
				_columnFDATE.AllowDBNull = true;
				_columnFDATE.Caption = "Fdate";
				_columnFDATE.Unique = false;
				_columnFDATE.DefaultValue = Convert.DBNull;
				_columnFDATE.ExtendedProperties.Add("IsKey", "false");
				_columnFDATE.ExtendedProperties.Add("ReadOnly", "false");
				_columnFDATE.ExtendedProperties.Add("Description", "Fdate");
				_columnFDATE.ExtendedProperties.Add("Decimals", "0");
				_columnFDATE.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnFDATE);
				
				_columnLUSER = new DataColumn("LUSER", typeof(string), "", MappingType.Element);
				_columnLUSER.AllowDBNull = true;
				_columnLUSER.Caption = "Luser";
				_columnLUSER.Unique = false;
				_columnLUSER.DefaultValue = Convert.DBNull;
				_columnLUSER.ExtendedProperties.Add("IsKey", "false");
				_columnLUSER.ExtendedProperties.Add("ReadOnly", "false");
				_columnLUSER.ExtendedProperties.Add("Description", "Luser");
				_columnLUSER.ExtendedProperties.Add("Decimals", "0");
				_columnLUSER.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnLUSER);
				
				_columnLDATE = new DataColumn("LDATE", typeof(DateTime), "", MappingType.Element);
				_columnLDATE.AllowDBNull = true;
				_columnLDATE.Caption = "Ldate";
				_columnLDATE.Unique = false;
				_columnLDATE.DefaultValue = Convert.DBNull;
				_columnLDATE.ExtendedProperties.Add("IsKey", "false");
				_columnLDATE.ExtendedProperties.Add("ReadOnly", "false");
				_columnLDATE.ExtendedProperties.Add("Description", "Ldate");
				_columnLDATE.ExtendedProperties.Add("Decimals", "0");
				_columnLDATE.ExtendedProperties.Add("AllowDBNulls", "true");
				this.Columns.Add(_columnLDATE);
				
			}
			
			public TABLELISTQueryCondRow NewTABLELISTQueryCondRow()
			{
				TABLELISTQueryCondRow rowTABLELISTQueryCondRow = ((TABLELISTQueryCondRow)(this.NewRow()));
				return rowTABLELISTQueryCondRow;
			}
			
			protected override DataRow NewRowFromBuilder(DataRowBuilder builder)
			{
				return new TABLELISTQueryCondRow(builder);
			}
			
			protected override Type GetRowType()
			{
				return typeof(TABLELISTQueryCondRow);
			}
			
			protected override void OnRowChanged(DataRowChangeEventArgs e)
			{
				base.OnRowChanged(e);
				if (this.TABLELISTQueryCondRowChanged != null)
				{
					this.TABLELISTQueryCondRowChanged(this, new TABLELISTQueryCondRowChangeEventArgs(((TABLELISTQueryCondRow)(e.Row)), e.Action));
				}
			}
			
			protected override void OnRowChanging(DataRowChangeEventArgs e)
			{
				base.OnRowChanging(e);
				if (this.TABLELISTQueryCondRowChanging != null)
				{
					this.TABLELISTQueryCondRowChanging(this, new TABLELISTQueryCondRowChangeEventArgs(((TABLELISTQueryCondRow)(e.Row)), e.Action));
				}
			}
			
			protected override void OnRowDeleted(DataRowChangeEventArgs e)
			{
				base.OnRowDeleted(e);
				if (this.TABLELISTQueryCondRowDeleted != null)
				{
					this.TABLELISTQueryCondRowDeleted(this, new TABLELISTQueryCondRowChangeEventArgs(((TABLELISTQueryCondRow)(e.Row)), e.Action));
				}
			}
			
			protected override void OnRowDeleting(DataRowChangeEventArgs e)
			{
				base.OnRowDeleting(e);
				if (this.TABLELISTQueryCondRowDeleting != null)
				{
					this.TABLELISTQueryCondRowDeleting(this, new TABLELISTQueryCondRowChangeEventArgs(((TABLELISTQueryCondRow)(e.Row)), e.Action));
				}
			}
			
			public void RemoveTABLELISTQueryCondRow(TABLELISTQueryCondRow row)
			{
				this.Rows.Remove(row);
			}
		}
		
		public class TABLELISTQueryCondRow: DataRow
		{
			private TABLELISTQueryCondDataTable _tableTABLELISTQueryCond;
			
			internal TABLELISTQueryCondRow(DataRowBuilder rb): base(rb)
			{
				_tableTABLELISTQueryCond = ((TABLELISTQueryCondDataTable)(this.Table));
			}
			
			/// <summary>
			/// Gets or sets the value of QUERYTYPE property
			/// </summary>
			public string QUERYTYPE
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.QUERYTYPEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value QUERYTYPE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.QUERYTYPEColumn] = value;
				}
			}
			
			public bool IsQUERYTYPENull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.QUERYTYPEColumn);
			}
			
			public void SetQUERYTYPENull()
			{
				this[_tableTABLELISTQueryCond.QUERYTYPEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of CONDTYPE property
			/// </summary>
			public string CONDTYPE
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.CONDTYPEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value CONDTYPE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.CONDTYPEColumn] = value;
				}
			}
			
			public bool IsCONDTYPENull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.CONDTYPEColumn);
			}
			
			public void SetCONDTYPENull()
			{
				this[_tableTABLELISTQueryCond.CONDTYPEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of REASON1 property
			/// </summary>
			public string REASON1
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.REASON1Column]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value REASON1 because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.REASON1Column] = value;
				}
			}
			
			public bool IsREASON1Null()
			{
				return this.IsNull(_tableTABLELISTQueryCond.REASON1Column);
			}
			
			public void SetREASON1Null()
			{
				this[_tableTABLELISTQueryCond.REASON1Column] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of FKREAL property
			/// </summary>
			public string FKREAL
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.FKREALColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value FKREAL because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.FKREALColumn] = value;
				}
			}
			
			public bool IsFKREALNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.FKREALColumn);
			}
			
			public void SetFKREALNull()
			{
				this[_tableTABLELISTQueryCond.FKREALColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SM property
			/// </summary>
			public string SM
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.SMColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SM because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.SMColumn] = value;
				}
			}
			
			public bool IsSMNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.SMColumn);
			}
			
			public void SetSMNull()
			{
				this[_tableTABLELISTQueryCond.SMColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of UID property
			/// </summary>
			public string UID
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.UIDColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value UID because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.UIDColumn] = value;
				}
			}
			
			public bool IsUIDNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.UIDColumn);
			}
			
			public void SetUIDNull()
			{
				this[_tableTABLELISTQueryCond.UIDColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GTPRE property
			/// </summary>
			public string GTPRE
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.GTPREColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GTPRE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.GTPREColumn] = value;
				}
			}
			
			public bool IsGTPRENull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.GTPREColumn);
			}
			
			public void SetGTPRENull()
			{
				this[_tableTABLELISTQueryCond.GTPREColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GTKEY property
			/// </summary>
			public string GTKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.GTKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GTKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.GTKEYColumn] = value;
				}
			}
			
			public bool IsGTKEYNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.GTKEYColumn);
			}
			
			public void SetGTKEYNull()
			{
				this[_tableTABLELISTQueryCond.GTKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of GDKEY property
			/// </summary>
			public string GDKEY
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.GDKEYColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value GDKEY because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.GDKEYColumn] = value;
				}
			}
			
			public bool IsGDKEYNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.GDKEYColumn);
			}
			
			public void SetGDKEYNull()
			{
				this[_tableTABLELISTQueryCond.GDKEYColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of TABLEID property
			/// </summary>
			public string TABLEID
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.TABLEIDColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value TABLEID because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.TABLEIDColumn] = value;
				}
			}
			
			public bool IsTABLEIDNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.TABLEIDColumn);
			}
			
			public void SetTABLEIDNull()
			{
				this[_tableTABLELISTQueryCond.TABLEIDColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of TABLENAME property
			/// </summary>
			public string TABLENAME
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.TABLENAMEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value TABLENAME because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.TABLENAMEColumn] = value;
				}
			}
			
			public bool IsTABLENAMENull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.TABLENAMEColumn);
			}
			
			public void SetTABLENAMENull()
			{
				this[_tableTABLELISTQueryCond.TABLENAMEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SHORTNAME property
			/// </summary>
			public string SHORTNAME
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.SHORTNAMEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SHORTNAME because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.SHORTNAMEColumn] = value;
				}
			}
			
			public bool IsSHORTNAMENull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.SHORTNAMEColumn);
			}
			
			public void SetSHORTNAMENull()
			{
				this[_tableTABLELISTQueryCond.SHORTNAMEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of KEYCONDITION property
			/// </summary>
			public string KEYCONDITION
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.KEYCONDITIONColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value KEYCONDITION because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.KEYCONDITIONColumn] = value;
				}
			}
			
			public bool IsKEYCONDITIONNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.KEYCONDITIONColumn);
			}
			
			public void SetKEYCONDITIONNull()
			{
				this[_tableTABLELISTQueryCond.KEYCONDITIONColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of TABLEGROUP property
			/// </summary>
			public string TABLEGROUP
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.TABLEGROUPColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value TABLEGROUP because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.TABLEGROUPColumn] = value;
				}
			}
			
			public bool IsTABLEGROUPNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.TABLEGROUPColumn);
			}
			
			public void SetTABLEGROUPNull()
			{
				this[_tableTABLELISTQueryCond.TABLEGROUPColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of TABLECLASS property
			/// </summary>
			public string TABLECLASS
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.TABLECLASSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value TABLECLASS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.TABLECLASSColumn] = value;
				}
			}
			
			public bool IsTABLECLASSNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.TABLECLASSColumn);
			}
			
			public void SetTABLECLASSNull()
			{
				this[_tableTABLELISTQueryCond.TABLECLASSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of FOREIGNKEYPROTECTED property
			/// </summary>
			public string FOREIGNKEYPROTECTED
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.FOREIGNKEYPROTECTEDColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value FOREIGNKEYPROTECTED because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.FOREIGNKEYPROTECTEDColumn] = value;
				}
			}
			
			public bool IsFOREIGNKEYPROTECTEDNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.FOREIGNKEYPROTECTEDColumn);
			}
			
			public void SetFOREIGNKEYPROTECTEDNull()
			{
				this[_tableTABLELISTQueryCond.FOREIGNKEYPROTECTEDColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of SUBSTATUS property
			/// </summary>
			public string SUBSTATUS
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.SUBSTATUSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value SUBSTATUS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.SUBSTATUSColumn] = value;
				}
			}
			
			public bool IsSUBSTATUSNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.SUBSTATUSColumn);
			}
			
			public void SetSUBSTATUSNull()
			{
				this[_tableTABLELISTQueryCond.SUBSTATUSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of STATUS property
			/// </summary>
			public string STATUS
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.STATUSColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value STATUS because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.STATUSColumn] = value;
				}
			}
			
			public bool IsSTATUSNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.STATUSColumn);
			}
			
			public void SetSTATUSNull()
			{
				this[_tableTABLELISTQueryCond.STATUSColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of FUSER property
			/// </summary>
			public string FUSER
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.FUSERColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value FUSER because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.FUSERColumn] = value;
				}
			}
			
			public bool IsFUSERNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.FUSERColumn);
			}
			
			public void SetFUSERNull()
			{
				this[_tableTABLELISTQueryCond.FUSERColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of FDATE property
			/// </summary>
			public DateTime FDATE
			{
				get
				{
					try
					{
						return ((DateTime)(this[_tableTABLELISTQueryCond.FDATEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value FDATE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.FDATEColumn] = value;
				}
			}
			
			public bool IsFDATENull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.FDATEColumn);
			}
			
			public void SetFDATENull()
			{
				this[_tableTABLELISTQueryCond.FDATEColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of LUSER property
			/// </summary>
			public string LUSER
			{
				get
				{
					try
					{
						return ((string)(this[_tableTABLELISTQueryCond.LUSERColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value LUSER because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.LUSERColumn] = value;
				}
			}
			
			public bool IsLUSERNull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.LUSERColumn);
			}
			
			public void SetLUSERNull()
			{
				this[_tableTABLELISTQueryCond.LUSERColumn] = Convert.DBNull;
			}
			
			/// <summary>
			/// Gets or sets the value of LDATE property
			/// </summary>
			public DateTime LDATE
			{
				get
				{
					try
					{
						return ((DateTime)(this[_tableTABLELISTQueryCond.LDATEColumn]));
					}
					catch (InvalidCastException exception)
					{
						throw new StrongTypingException("Cannot get value LDATE because it is DBNull.", exception);
					}
				}
				set
				{
					this[_tableTABLELISTQueryCond.LDATEColumn] = value;
				}
			}
			
			public bool IsLDATENull()
			{
				return this.IsNull(_tableTABLELISTQueryCond.LDATEColumn);
			}
			
			public void SetLDATENull()
			{
				this[_tableTABLELISTQueryCond.LDATEColumn] = Convert.DBNull;
			}
			
		}
		
		public class TABLELISTQueryCondRowChangeEventArgs: EventArgs
		{
			private TABLELISTQueryCondRow _eventRow;
			private System.Data.DataRowAction _eventAction;
			
			public TABLELISTQueryCondRowChangeEventArgs(TABLELISTQueryCondRow row, DataRowAction action)
			{
				_eventRow = row;
				_eventAction = action;
			}
			
			public TABLELISTQueryCondRow Row
			{
				get
				{
					return _eventRow;
				}
			}
			
			public DataRowAction Action
			{
				get
				{
					return _eventAction;
				}
			}
		}
	}
	#endregion
    }
